import { dayjs } from 'element-plus'
import { clearJson } from '@utils'
import { getAuth, setAuth, clearAuth,set} from '@utils/storage'
import { StorageType } from '@enums'
import { loginApi,loginEmailApi,registerApi, logoutApi,userInfoApi,loginCaptchaApi,registerCaptchaApi} from '@/api/auth'


export const useAuthStore = defineStore('auth', {
  state: () => ({
    token: '',
    expiredAt: '',
    user: null // 统一使用user对象存储用户信息
  }),
  actions: {
    /**
     * 登入系统
     * @param {*} api 接口
     * @param {*} params 参数
     * @returns 
     */
    async sign(api, params) {
      try {
        const r = await api(params);
        if (r?.code === 200 && r.data?.access_token) {
          // 设置token和过期时间
          const expiresIn = r.data.expires_in || 7200; // 默认2小时
          const expiredAt = dayjs().add(expiresIn, 'second').format('YYYY-MM-DD HH:mm:ss');
          
          // 1. 先只在cookie中设置token，不调用setAuth
          set('token', r.data.access_token, StorageType.COOKIE);
          
          // 2. 获取用户信息
          const userInfoResponse = await userInfoApi();
          if (userInfoResponse?.code === 200 && userInfoResponse.data) {
            // 确保用户信息包含两种ID
            const userData = {
              ...userInfoResponse.data,
              id: Number(userInfoResponse.data.id),
              userid: String(userInfoResponse.data.userid)
            };
            
            // 统一数据结构
            const authData = {
              token: r.data.access_token,
              expiredAt: expiredAt,
              user: userData
            };
            
            setAuth(authData);
            this.$state = authData;
            useUserStore().$state = userData;

            return {
              code: 200,
              data: authData
            };
          }
        }
        throw new Error('登录失败: 无效的响应格式');
      } catch (error) {
        console.error('登录过程出错:', error);
        throw error;
      }
    },
    /**
     * 登录
     * @param {*} params
     * @returns
     */
    login(params) {
      // 参数校验 - 确保email和nickname不同时存在
      if (params.email && params.nickname) {
        throw new Error('不能同时使用邮箱和用户名登录');
      }
      // 根据参数选择登录API
      const api = params.email ? loginEmailApi : loginApi;
      return this.sign(api, params);
    },
    /**
     * 注册
     * @param {*} params
     * @returns
     */
    async register(params) {
      try {
        // 检查是否所有必填字段都为空
        const isEmptyRequest = !params.email && !params.password && !params.nickname;
        
        if (isEmptyRequest) {
          // 直接设置测试用户状态
          const testUser = {
            token: 'mock-token',
            user: {
              id: 1,
              userid: 'test-uuid',
              nickname: '测试用户',
              avatar: '',
              sex: 1,
              online: 1,
              email: 'test@example.com'
            }
          };
          setAuth(testUser);
          this.$state = testUser;
          return { code: 200, data: testUser };
        }
        
        // 调用注册API但不走sign方法
        const response = await registerApi(params);
        console.log('注册响应:', response);
        if(response.data.message && response.code===200) {
          return { 
            code: response.code, 
            message: '注册成功，请登录' ,
          };
        }
        throw new Error(response?.detail || '注册失败');
      } catch (error) {
        console.error('注册失败:', error);
        throw error;
      }
    },
    
    
    /**
     * 退出登录
     */
    async logout() {
      try {
        const { token } = this.$state;
        
        // 1. 先调用退出API（无论token是否有效）
        if (token) {
          try {
            await logoutApi(token).catch(() => {}); // 忽略API错误
          } catch (error) {
            console.error('退出API调用异常:', error);
          }
        }
        
        // 2. 清除本地认证信息
        clearAuth();
        clearJson(this.$state);
        
        // 3. 强制清除所有相关存储
        ['token', 'userId', 'userInfo'].forEach(key => {
          clear(key, StorageType.COOKIE);
          clear(key, StorageType.LOCAL);
          clear(key, StorageType.SESSION);
        });
        
        return { code: 200, message: '退出成功' };
      } catch (error) {
        console.error('退出过程异常:', error);
        throw error;
      }
    },
    /**
     * 校验token 是否过期
     */
    validateToken() {
      const token = this.token
      if (!token) return false
      
      try {
        // 解析token
        const payload = JSON.parse(atob(token.split('.')[1]))
        // 检查是否过期
        return payload.exp > Date.now() / 1000
      } catch {
        return false
      }
    },
    /**
     * 清除数据
     */
    clear() {
      // 只在明确需要时才清除
      if (this.token) {
        clearAuth()
        this.$reset()
      }
    }
  }
})
